﻿/**
 * \file VueVillePrincipale.cs
 * \brief Classe VueVillePrincipale
 * \author ARTUR Vincent
 * \author LAPERDRIX Pierre
 * \version 1.0
 */

namespace WpfJeu
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Windows.Controls;
    using Implem;
    using System.Windows.Media.Imaging;
    using System.Windows.Input;
    using System.Windows;
    using System.Windows.Shapes;
    using System.Windows.Media;


    /**
     * \class VueVillePrincipale
     * \brief Vue des villes du plateau de jeu
     */
    public class VueVillePrincipale : Canvas 
    {
        /*!< Ville du modèle associée à la vue*/
        private Ville _ville;
        /*!< Propriete accedant a l'attribut _ville */
        public Ville Ville
        {
            get { return _ville; }
            set { _ville = value; }
        }

        /*!< Rectangle affichant la couleur du joueur propriétaire*/
        private Rectangle _rect;
        /*!< Propriete accedant a l'attribut _rect */
        public Rectangle Rect
        {
            get { return _rect; }
            set { _rect = value; }
        }

        /*!< Booléen permettant de savoir si la ville appartient au joueur en train de jouer*/
        private bool _appartientJoueurCourant;
        /*!< Propriete accedant a l'attribut _appartientJoueurCourant */
        public bool AppartientJoueurCourant
        {
            get { return _appartientJoueurCourant; }
            set { _appartientJoueurCourant = value; }
        }

        /******************* Handlers *******************/

 
        /*!< Routed Event permettant de dire a la grille de la carte d'ajouter une nouvelle unite quand celle-ci est produite par la vue  */
        public static readonly RoutedEvent NouvelleUniteEvent = EventManager.RegisterRoutedEvent(
            "NouvelleUnite", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(VueVillePrincipale));

        /*!< Propriete ajoutant/supprimant l'event NouvelleUniteEvent */
        public event RoutedEventHandler NouvelleUnite
        {
            add { AddHandler(NouvelleUniteEvent, value); }
            remove { RemoveHandler(NouvelleUniteEvent, value); }
        }


        /*!< Routed Event permettant de dire a la grille de la carte d'ajouter une expansion de la ville */
        public static readonly RoutedEvent NouvelleExpansionEvent = EventManager.RegisterRoutedEvent(
            "NouvelleExpansion", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(VueVillePrincipale));

        /*!< Propriete ajoutant/supprimant l'event NouvelleExpansionEvent */
        public event RoutedEventHandler NouvelleExpansion
        {
            add { AddHandler(NouvelleExpansionEvent, value); }
            remove { RemoveHandler(NouvelleExpansionEvent, value); }
        }


        /*!< Routed Event pour que le clic sur une ville soit gere par le MainWindow  */
        public static readonly RoutedEvent ClickVilleEvent = EventManager.RegisterRoutedEvent(
            "ClickVille", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(VueVillePrincipale));

        /*!< Propriete ajoutant/supprimant l'event ClickVilleEvent */
        public event RoutedEventHandler ClickVille
        {
            add { AddHandler(ClickVilleEvent, value); }
            remove { RemoveHandler(ClickVilleEvent, value); }
        }

        /*!< Routed Event permettant de dire a la grille de la prise d'une ville */
        public static readonly RoutedEvent PriseEvent = EventManager.RegisterRoutedEvent(
            "Prise", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(VueCase));

        /*!< Propriete ajoutant/supprimant l'event PriseEvent */
        public event RoutedEventHandler Prise
        {
            add { AddHandler(PriseEvent, value); }
            remove { RemoveHandler(PriseEvent, value); }
        }

        /******************* Methodes *******************/

        /**
         * \fn public VueVillePrincipale(Ville v)
         * \brief Constructeur de VueVillePrincipale
         * \param v la ville liée à cette vue
         */
        public VueVillePrincipale(Ville v)
        {
            Ville = v;
            AppartientJoueurCourant = true;
            int longueur = 65;
            int hauteur = 30;

            //Position du canvas et taille
            Canvas.SetZIndex(this, 1);
            this.Width = longueur;
            this.Height = hauteur;

            //Creation du rectangle du couleur du joueur
            Rect  = new Rectangle();
            Rect.Width = longueur;
            Rect.Height = hauteur;
            Rect.Fill = new SolidColorBrush(this.Ville.JoueurProprietaire.Couleur);
            Canvas.SetZIndex(Rect, 2);
            this.Children.Add(Rect);

            //Ajout de la source de l'image
            Image img = new Image();
            img.Source = new BitmapImage(new Uri("/WpfJeu;component/Ressources/ville.png", UriKind.Relative));
            Canvas.SetZIndex(img, 3);
            this.Children.Add(img);

            //Ajout d'un handler pour le clic gauche
            this.MouseLeftButtonDown += new MouseButtonEventHandler(ville_MouseLeftButtonDown);

            //Ajout des handlers
            Ville.ExpansionEvent += this.creerVueVilleExpansion;
            Ville.ProductionEvent += this.creerVueUnite;
            Ville.PriseEvent += this.priseVille;

        }

        /**
         * \fn private void ville_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
         * \brief Envoi d'un event à la MainWindow pour la prise en charge du clic sur la ville
         * \param sender
         * \param e
         */
        private void ville_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            //Event handled
            e.Handled = true;

            //Declenchement de l'evenement ClickEvent
            RoutedEventArgs newEventArgs = new RoutedEventArgs(VueVillePrincipale.ClickVilleEvent);
            RaiseEvent(newEventArgs);
        }

        /**
         * \fn public void creerVueVilleExpansion(object sender, Ville.ExpansionVilleEventArgs args)
         * \brief Création d'une VueVilleExpansion associée à cette VueVillePrincipale
         * \param sender
         * \param e
         */
        public void creerVueVilleExpansion(object sender, Ville.ExpansionVilleEventArgs args)
        {
            //Creation de la vue additionnelle
            VueVilleExpansion vve = new VueVilleExpansion(this,args.pos);

            //Envoie a la grille de la nouvelle Expansion
            RoutedEventArgs newEventArgs = new RoutedEventArgs(VueVillePrincipale.NouvelleExpansionEvent, vve);
            RaiseEvent(newEventArgs);
        }

        /**
         * \fn public void creerVueUnite(object sender, Ville.UniteProduiteEventArgs args)
         * \brief Création d'une VueUnité produite par la ville associée à cette vue
         * \param sender
         * \param e
         */
        public void creerVueUnite(object sender, Ville.UniteProduiteEventArgs args)
        {
            //Creation de la vue pour l'unite
            VueUnite vu = new VueUnite((Unite)args.unite);

            //Envoie a la grille de la nouvelle Unite
            RoutedEventArgs newEventArgs = new RoutedEventArgs(VueVillePrincipale.NouvelleUniteEvent, vu);
            RaiseEvent(newEventArgs);
        }

        /**
         * \fn public void priseVille(object sender, EventArgs args)
         * \brief Change la couleur du rectangle lors de la prise de la ville par un autre joueur
         * \param sender
         * \param e
         */
        public void priseVille(object sender, Ville.PriseEventArgs args)
        {
            //Changement de la couleur du rectangle
            Rect.Fill = new SolidColorBrush(this.Ville.JoueurProprietaire.Couleur);

            //Envoie a la grille de l'information
            KeyValuePair<Joueur, VueVillePrincipale> tmp = new KeyValuePair<Joueur, VueVillePrincipale>(args.ancienProp, this);
            RoutedEventArgs newEventArgs = new RoutedEventArgs(VueVillePrincipale.PriseEvent,tmp);
            RaiseEvent(newEventArgs);
        }
    }
}
